package com.example.onlinemonitoring.model;

import com.example.onlinemonitoring.model.common.sensor;
import java.util.Date;
import javax.persistence.*;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.example.onlinemonitoring.AOP.Float2Serializer;

public class Dlqjcsensor extends sensor {
    /**
     * 断路器监测的编号，主键，自动递增。
     */
    @Id
    private Long id;

    /**
     * 监测点
     */
    private Integer stationid;

    /**
     * 设备地址
     */
    private Integer deviceaddr;

    private Integer devicegroup;

    /**
     * 设备名称。
     */
    private String pointname;

    /**
     * 当前时间
     */
    private Date lastdatatime;

    @JsonSerialize(using = Float2Serializer.class)
    private Float lasti0current;

    @JsonSerialize(using = Float2Serializer.class)
    private Float lasti1current;

    @JsonSerialize(using = Float2Serializer.class)
    private Float lasti2current;

    @JsonSerialize(using = Float2Serializer.class)
    private Float lasti3current;

    @JsonSerialize(using = Float2Serializer.class)
    private Float lasti4current;

    @JsonSerialize(using = Float2Serializer.class)
    private Float lasti5current;

    /**
     * I0状态电流对应时间T0（相对值）
     */
    private Integer lastt0time;

    /**
     * I1状态电流对应时间T1（相对值）
     */
    private Integer lastt1time;

    /**
     * I2状态电流对应时间T2（相对值）
     */
    private Integer lastt2time;

    /**
     * I3状态电流对应时间T3（相对值）
     */
    private Integer lastt3time;

    /**
     * I4状态电流对应时间T4（相对值）
     */
    private Integer lastt4time;

    /**
     * I5状态电流对应时间T5（相对值）
     */
    private Integer lastt5time;

    /**
     * 路器断三相（64A相、65B相、66C相、67总）
     */
    private Integer cmd;

    /**
     * 断路器状态（合闸1、主分2、副分3、储能4）(43命令A相0未知，1合闸，2分闸)
     */
    private Integer laststate;

    /**
     * A相储能状态：0未知，1储能；2未储能
     */
    private Integer laststoragestate;

    /**
     * 动作(合闸、分闸)发生前的电流A相
     */
    @JsonSerialize(using = Float2Serializer.class)
    private Float lastaccurrent;

    /**
     * 动作(合闸、分闸)发生前的电流B相
     */
    @JsonSerialize(using = Float2Serializer.class)
    private Float lastbccurrent;

    /**
     * 动作(合闸、分闸)发生前的电流
     */
    @JsonSerialize(using = Float2Serializer.class)
    private Float lastcccurrent;

    /**
     * 报警等级，0正常，1报警
     */
    private Integer lastalarmlevel;

    /**
     * 报警信息
     */
    private String lastalarmmessage;

    /**
     * 通信状态。 0表示正常，1表示异常。不论通信成功或者失败，都必须修改此值。
     */
    private Integer lastcommunicationstatus;

    /**
     * 该设备是否投运。1为投运，0为不投运。不投运的装置，在查看模式不显示，尽在设计模式时显示。
     */
    private Integer inuse;

    /**
     * 测试数据0为工作数据，1为实验数据
     */
    private Integer testdata;

    /**
     * (43命令B相0未知，1合闸，2分闸)
     */
    private Integer lastastate;

    /**
     * B相储能状态：0未知，1储能，2未储能
     */
    private Integer lastastoragestate;

    /**
     * (43命令B相0未知，1合闸，2分闸)
     */
    private Integer lastbstate;

    /**
     * (43命令C相0未知，1合闸，2分闸)
     */
    private Integer lastcstate;

    /**
     * B相储能状态：0未知，1储能，2未储能
     */
    private Integer lastbstoragestate;

    /**
     * C相储能状态：0未知，1储能，2未储能
     */
    private Integer lastcstoragestate;

    /**
     * A相次数
     */
    private Long acount;

    /**
     * B相次数
     */
    private Long bcount;

    /**
     * C相次数
     */
    private Long ccount;

    @JsonSerialize(using = Float2Serializer.class)
    private Float lifetime;

    /**
     * 最大寿命
     */
    private Integer dlqjctdnumb;

    /**
     * 当前寿命
     */
    private Integer lastdlqjctdnumb;

    @JsonSerialize(using = Float2Serializer.class)
    private Float t2t2d;

    @JsonSerialize(using = Float2Serializer.class)
    private Float t3t3d;

    @JsonSerialize(using = Float2Serializer.class)
    private Float t4t4d;

    @JsonSerialize(using = Float2Serializer.class)
    private Float i2i2d;

    @JsonSerialize(using = Float2Serializer.class)
    private Float i32i2;

    @JsonSerialize(using = Float2Serializer.class)
    private Float i40;

    @JsonSerialize(using = Float2Serializer.class)
    private Float i50;

    @JsonSerialize(using = Float2Serializer.class)
    private Float t5t5d;

    @JsonSerialize(using = Float2Serializer.class)
    private Float t1t0t1dt0d;

    @JsonSerialize(using = Float2Serializer.class)
    private Float t2t1t2dt1d;

    /**
     * 动作(合闸、分闸)发生后的电流A相
     */
    @JsonSerialize(using = Float2Serializer.class)
    private Float lastaacurrent;

    @JsonSerialize(using = Float2Serializer.class)
    private Float lastbacurrent;

    /**
     * 断路器B相电流
     */
    @JsonSerialize(using = Float2Serializer.class)
    private Float lastcacurrent;

    /**
     * 断路器B相电流
     */
    private Integer lastaastatus;

    /**
     * 断路器B相电流
     */
    private Integer lastbastatus;

    /**
     * 断路器B相电流
     */
    private Integer lastcastatus;

    @JsonSerialize(using = Float2Serializer.class)
    private Float coeconfig;

    @JsonSerialize(using = Float2Serializer.class)
    private Float ratioconfig;

    @JsonSerialize(using = Float2Serializer.class)
    private Float maxlifeconfig;

    /**
     * 字段的显示和隐藏
     */
    private String style;

    /**
     * 该指标0或者1判断是否将该条数据上传过61850,如果没有则上传,默认1已上传
     */
    private Integer upload;

    /**
     * 备注信息。
     */
    private String memo;

    private Integer lastst0time;

    private Integer lastst1time;

    private Integer lastst2time;

    private Integer lastst3time;

    private Integer lastst4time;

    private Integer lastst5time;

    /**
     * s0行程
     */
    private Integer lasts0;

    /**
     * s1行程
     */
    private Integer lasts1;

    /**
     * s2行程
     */
    private Integer lasts2;

    private Integer lasts3;

    private Integer lasts4;

    private Integer lasts5;

    /**
     * 刚分合
     */
    @JsonSerialize(using = Float2Serializer.class)
    private Float lastspeed;

    private Integer trip;

    private Integer od;

    private Integer firsts2;

    /**
     * 获取断路器监测的编号，主键，自动递增。
     *
     * @return id - 断路器监测的编号，主键，自动递增。
     */
    public Long getId() {
        return id;
    }

    /**
     * 设置断路器监测的编号，主键，自动递增。
     *
     * @param id 断路器监测的编号，主键，自动递增。
     */
    public void setId(Long id) {
        this.id = id;
    }

    /**
     * 获取监测点
     *
     * @return stationid - 监测点
     */
    public Integer getStationid() {
        return stationid;
    }

    /**
     * 设置监测点
     *
     * @param stationid 监测点
     */
    public void setStationid(Integer stationid) {
        this.stationid = stationid;
    }

    /**
     * 获取设备地址
     *
     * @return deviceaddr - 设备地址
     */
    public Integer getDeviceaddr() {
        return deviceaddr;
    }

    /**
     * 设置设备地址
     *
     * @param deviceaddr 设备地址
     */
    public void setDeviceaddr(Integer deviceaddr) {
        this.deviceaddr = deviceaddr;
    }

    /**
     * @return devicegroup
     */
    public Integer getDevicegroup() {
        return devicegroup;
    }

    /**
     * @param devicegroup
     */
    public void setDevicegroup(Integer devicegroup) {
        this.devicegroup = devicegroup;
    }

    /**
     * 获取设备名称。
     *
     * @return pointname - 设备名称。
     */
    public String getPointname() {
        return pointname;
    }

    /**
     * 设置设备名称。
     *
     * @param pointname 设备名称。
     */
    public void setPointname(String pointname) {
        this.pointname = pointname;
    }

    /**
     * 获取当前时间
     *
     * @return lastdatatime - 当前时间
     */
    public Date getLastdatatime() {
        return lastdatatime;
    }

    /**
     * 设置当前时间
     *
     * @param lastdatatime 当前时间
     */
    public void setLastdatatime(Date lastdatatime) {
        this.lastdatatime = lastdatatime;
    }

    /**
     * @return lasti0current
     */
    public Float getLasti0current() {
        return lasti0current;
    }

    /**
     * @param lasti0current
     */
    public void setLasti0current(Float lasti0current) {
        this.lasti0current = lasti0current;
    }

    /**
     * @return lasti1current
     */
    public Float getLasti1current() {
        return lasti1current;
    }

    /**
     * @param lasti1current
     */
    public void setLasti1current(Float lasti1current) {
        this.lasti1current = lasti1current;
    }

    /**
     * @return lasti2current
     */
    public Float getLasti2current() {
        return lasti2current;
    }

    /**
     * @param lasti2current
     */
    public void setLasti2current(Float lasti2current) {
        this.lasti2current = lasti2current;
    }

    /**
     * @return lasti3current
     */
    public Float getLasti3current() {
        return lasti3current;
    }

    /**
     * @param lasti3current
     */
    public void setLasti3current(Float lasti3current) {
        this.lasti3current = lasti3current;
    }

    /**
     * @return lasti4current
     */
    public Float getLasti4current() {
        return lasti4current;
    }

    /**
     * @param lasti4current
     */
    public void setLasti4current(Float lasti4current) {
        this.lasti4current = lasti4current;
    }

    /**
     * @return lasti5current
     */
    public Float getLasti5current() {
        return lasti5current;
    }

    /**
     * @param lasti5current
     */
    public void setLasti5current(Float lasti5current) {
        this.lasti5current = lasti5current;
    }

    /**
     * 获取I0状态电流对应时间T0（相对值）
     *
     * @return lastt0time - I0状态电流对应时间T0（相对值）
     */
    public Integer getLastt0time() {
        return lastt0time;
    }

    /**
     * 设置I0状态电流对应时间T0（相对值）
     *
     * @param lastt0time I0状态电流对应时间T0（相对值）
     */
    public void setLastt0time(Integer lastt0time) {
        this.lastt0time = lastt0time;
    }

    /**
     * 获取I1状态电流对应时间T1（相对值）
     *
     * @return lastt1time - I1状态电流对应时间T1（相对值）
     */
    public Integer getLastt1time() {
        return lastt1time;
    }

    /**
     * 设置I1状态电流对应时间T1（相对值）
     *
     * @param lastt1time I1状态电流对应时间T1（相对值）
     */
    public void setLastt1time(Integer lastt1time) {
        this.lastt1time = lastt1time;
    }

    /**
     * 获取I2状态电流对应时间T2（相对值）
     *
     * @return lastt2time - I2状态电流对应时间T2（相对值）
     */
    public Integer getLastt2time() {
        return lastt2time;
    }

    /**
     * 设置I2状态电流对应时间T2（相对值）
     *
     * @param lastt2time I2状态电流对应时间T2（相对值）
     */
    public void setLastt2time(Integer lastt2time) {
        this.lastt2time = lastt2time;
    }

    /**
     * 获取I3状态电流对应时间T3（相对值）
     *
     * @return lastt3time - I3状态电流对应时间T3（相对值）
     */
    public Integer getLastt3time() {
        return lastt3time;
    }

    /**
     * 设置I3状态电流对应时间T3（相对值）
     *
     * @param lastt3time I3状态电流对应时间T3（相对值）
     */
    public void setLastt3time(Integer lastt3time) {
        this.lastt3time = lastt3time;
    }

    /**
     * 获取I4状态电流对应时间T4（相对值）
     *
     * @return lastt4time - I4状态电流对应时间T4（相对值）
     */
    public Integer getLastt4time() {
        return lastt4time;
    }

    /**
     * 设置I4状态电流对应时间T4（相对值）
     *
     * @param lastt4time I4状态电流对应时间T4（相对值）
     */
    public void setLastt4time(Integer lastt4time) {
        this.lastt4time = lastt4time;
    }

    /**
     * 获取I5状态电流对应时间T5（相对值）
     *
     * @return lastt5time - I5状态电流对应时间T5（相对值）
     */
    public Integer getLastt5time() {
        return lastt5time;
    }

    /**
     * 设置I5状态电流对应时间T5（相对值）
     *
     * @param lastt5time I5状态电流对应时间T5（相对值）
     */
    public void setLastt5time(Integer lastt5time) {
        this.lastt5time = lastt5time;
    }

    /**
     * 获取路器断三相（64A相、65B相、66C相、67总）
     *
     * @return cmd - 路器断三相（64A相、65B相、66C相、67总）
     */
    public Integer getCmd() {
        return cmd;
    }

    /**
     * 设置路器断三相（64A相、65B相、66C相、67总）
     *
     * @param cmd 路器断三相（64A相、65B相、66C相、67总）
     */
    public void setCmd(Integer cmd) {
        this.cmd = cmd;
    }

    /**
     * 获取断路器状态（合闸1、主分2、副分3、储能4）(43命令A相0未知，1合闸，2分闸)
     *
     * @return laststate - 断路器状态（合闸1、主分2、副分3、储能4）(43命令A相0未知，1合闸，2分闸)
     */
    public Integer getLaststate() {
        return laststate;
    }

    /**
     * 设置断路器状态（合闸1、主分2、副分3、储能4）(43命令A相0未知，1合闸，2分闸)
     *
     * @param laststate 断路器状态（合闸1、主分2、副分3、储能4）(43命令A相0未知，1合闸，2分闸)
     */
    public void setLaststate(Integer laststate) {
        this.laststate = laststate;
    }

    /**
     * 获取A相储能状态：0未知，1储能；2未储能
     *
     * @return laststoragestate - A相储能状态：0未知，1储能；2未储能
     */
    public Integer getLaststoragestate() {
        return laststoragestate;
    }

    /**
     * 设置A相储能状态：0未知，1储能；2未储能
     *
     * @param laststoragestate A相储能状态：0未知，1储能；2未储能
     */
    public void setLaststoragestate(Integer laststoragestate) {
        this.laststoragestate = laststoragestate;
    }

    /**
     * 获取动作(合闸、分闸)发生前的电流A相
     *
     * @return lastaccurrent - 动作(合闸、分闸)发生前的电流A相
     */
    public Float getLastaccurrent() {
        return lastaccurrent;
    }

    /**
     * 设置动作(合闸、分闸)发生前的电流A相
     *
     * @param lastaccurrent 动作(合闸、分闸)发生前的电流A相
     */
    public void setLastaccurrent(Float lastaccurrent) {
        this.lastaccurrent = lastaccurrent;
    }

    /**
     * 获取动作(合闸、分闸)发生前的电流B相
     *
     * @return lastbccurrent - 动作(合闸、分闸)发生前的电流B相
     */
    public Float getLastbccurrent() {
        return lastbccurrent;
    }

    /**
     * 设置动作(合闸、分闸)发生前的电流B相
     *
     * @param lastbccurrent 动作(合闸、分闸)发生前的电流B相
     */
    public void setLastbccurrent(Float lastbccurrent) {
        this.lastbccurrent = lastbccurrent;
    }

    /**
     * 获取动作(合闸、分闸)发生前的电流
     *
     * @return lastcccurrent - 动作(合闸、分闸)发生前的电流
     */
    public Float getLastcccurrent() {
        return lastcccurrent;
    }

    /**
     * 设置动作(合闸、分闸)发生前的电流
     *
     * @param lastcccurrent 动作(合闸、分闸)发生前的电流
     */
    public void setLastcccurrent(Float lastcccurrent) {
        this.lastcccurrent = lastcccurrent;
    }

    /**
     * 获取报警等级，0正常，1报警
     *
     * @return lastalarmlevel - 报警等级，0正常，1报警
     */
    public Integer getLastalarmlevel() {
        return lastalarmlevel;
    }

    /**
     * 设置报警等级，0正常，1报警
     *
     * @param lastalarmlevel 报警等级，0正常，1报警
     */
    public void setLastalarmlevel(Integer lastalarmlevel) {
        this.lastalarmlevel = lastalarmlevel;
    }

    /**
     * 获取报警信息
     *
     * @return lastalarmmessage - 报警信息
     */
    public String getLastalarmmessage() {
        return lastalarmmessage;
    }

    /**
     * 设置报警信息
     *
     * @param lastalarmmessage 报警信息
     */
    public void setLastalarmmessage(String lastalarmmessage) {
        this.lastalarmmessage = lastalarmmessage;
    }

    /**
     * 获取通信状态。 0表示正常，1表示异常。不论通信成功或者失败，都必须修改此值。
     *
     * @return lastcommunicationstatus - 通信状态。 0表示正常，1表示异常。不论通信成功或者失败，都必须修改此值。
     */
    public Integer getLastcommunicationstatus() {
        return lastcommunicationstatus;
    }

    /**
     * 设置通信状态。 0表示正常，1表示异常。不论通信成功或者失败，都必须修改此值。
     *
     * @param lastcommunicationstatus 通信状态。 0表示正常，1表示异常。不论通信成功或者失败，都必须修改此值。
     */
    public void setLastcommunicationstatus(Integer lastcommunicationstatus) {
        this.lastcommunicationstatus = lastcommunicationstatus;
    }

    /**
     * 获取该设备是否投运。1为投运，0为不投运。不投运的装置，在查看模式不显示，尽在设计模式时显示。
     *
     * @return inuse - 该设备是否投运。1为投运，0为不投运。不投运的装置，在查看模式不显示，尽在设计模式时显示。
     */
    public Integer getInuse() {
        return inuse;
    }

    /**
     * 设置该设备是否投运。1为投运，0为不投运。不投运的装置，在查看模式不显示，尽在设计模式时显示。
     *
     * @param inuse 该设备是否投运。1为投运，0为不投运。不投运的装置，在查看模式不显示，尽在设计模式时显示。
     */
    public void setInuse(Integer inuse) {
        this.inuse = inuse;
    }

    /**
     * 获取测试数据0为工作数据，1为实验数据
     *
     * @return testdata - 测试数据0为工作数据，1为实验数据
     */
    public Integer getTestdata() {
        return testdata;
    }

    /**
     * 设置测试数据0为工作数据，1为实验数据
     *
     * @param testdata 测试数据0为工作数据，1为实验数据
     */
    public void setTestdata(Integer testdata) {
        this.testdata = testdata;
    }

    /**
     * 获取(43命令B相0未知，1合闸，2分闸)
     *
     * @return lastastate - (43命令B相0未知，1合闸，2分闸)
     */
    public Integer getLastastate() {
        return lastastate;
    }

    /**
     * 设置(43命令B相0未知，1合闸，2分闸)
     *
     * @param lastastate (43命令B相0未知，1合闸，2分闸)
     */
    public void setLastastate(Integer lastastate) {
        this.lastastate = lastastate;
    }

    /**
     * 获取B相储能状态：0未知，1储能，2未储能
     *
     * @return lastastoragestate - B相储能状态：0未知，1储能，2未储能
     */
    public Integer getLastastoragestate() {
        return lastastoragestate;
    }

    /**
     * 设置B相储能状态：0未知，1储能，2未储能
     *
     * @param lastastoragestate B相储能状态：0未知，1储能，2未储能
     */
    public void setLastastoragestate(Integer lastastoragestate) {
        this.lastastoragestate = lastastoragestate;
    }

    /**
     * 获取(43命令B相0未知，1合闸，2分闸)
     *
     * @return lastbstate - (43命令B相0未知，1合闸，2分闸)
     */
    public Integer getLastbstate() {
        return lastbstate;
    }

    /**
     * 设置(43命令B相0未知，1合闸，2分闸)
     *
     * @param lastbstate (43命令B相0未知，1合闸，2分闸)
     */
    public void setLastbstate(Integer lastbstate) {
        this.lastbstate = lastbstate;
    }

    /**
     * 获取(43命令C相0未知，1合闸，2分闸)
     *
     * @return lastcstate - (43命令C相0未知，1合闸，2分闸)
     */
    public Integer getLastcstate() {
        return lastcstate;
    }

    /**
     * 设置(43命令C相0未知，1合闸，2分闸)
     *
     * @param lastcstate (43命令C相0未知，1合闸，2分闸)
     */
    public void setLastcstate(Integer lastcstate) {
        this.lastcstate = lastcstate;
    }

    /**
     * 获取B相储能状态：0未知，1储能，2未储能
     *
     * @return lastbstoragestate - B相储能状态：0未知，1储能，2未储能
     */
    public Integer getLastbstoragestate() {
        return lastbstoragestate;
    }

    /**
     * 设置B相储能状态：0未知，1储能，2未储能
     *
     * @param lastbstoragestate B相储能状态：0未知，1储能，2未储能
     */
    public void setLastbstoragestate(Integer lastbstoragestate) {
        this.lastbstoragestate = lastbstoragestate;
    }

    /**
     * 获取C相储能状态：0未知，1储能，2未储能
     *
     * @return lastcstoragestate - C相储能状态：0未知，1储能，2未储能
     */
    public Integer getLastcstoragestate() {
        return lastcstoragestate;
    }

    /**
     * 设置C相储能状态：0未知，1储能，2未储能
     *
     * @param lastcstoragestate C相储能状态：0未知，1储能，2未储能
     */
    public void setLastcstoragestate(Integer lastcstoragestate) {
        this.lastcstoragestate = lastcstoragestate;
    }

    /**
     * 获取A相次数
     *
     * @return acount - A相次数
     */
    public Long getAcount() {
        return acount;
    }

    /**
     * 设置A相次数
     *
     * @param acount A相次数
     */
    public void setAcount(Long acount) {
        this.acount = acount;
    }

    /**
     * 获取B相次数
     *
     * @return bcount - B相次数
     */
    public Long getBcount() {
        return bcount;
    }

    /**
     * 设置B相次数
     *
     * @param bcount B相次数
     */
    public void setBcount(Long bcount) {
        this.bcount = bcount;
    }

    /**
     * 获取C相次数
     *
     * @return ccount - C相次数
     */
    public Long getCcount() {
        return ccount;
    }

    /**
     * 设置C相次数
     *
     * @param ccount C相次数
     */
    public void setCcount(Long ccount) {
        this.ccount = ccount;
    }

    /**
     * @return lifetime
     */
    public Float getLifetime() {
        return lifetime;
    }

    /**
     * @param lifetime
     */
    public void setLifetime(Float lifetime) {
        this.lifetime = lifetime;
    }

    /**
     * 获取最大寿命
     *
     * @return dlqjctdnumb - 最大寿命
     */
    public Integer getDlqjctdnumb() {
        return dlqjctdnumb;
    }

    /**
     * 设置最大寿命
     *
     * @param dlqjctdnumb 最大寿命
     */
    public void setDlqjctdnumb(Integer dlqjctdnumb) {
        this.dlqjctdnumb = dlqjctdnumb;
    }

    /**
     * 获取当前寿命
     *
     * @return lastdlqjctdnumb - 当前寿命
     */
    public Integer getLastdlqjctdnumb() {
        return lastdlqjctdnumb;
    }

    /**
     * 设置当前寿命
     *
     * @param lastdlqjctdnumb 当前寿命
     */
    public void setLastdlqjctdnumb(Integer lastdlqjctdnumb) {
        this.lastdlqjctdnumb = lastdlqjctdnumb;
    }

    /**
     * @return t2t2d
     */
    public Float getT2t2d() {
        return t2t2d;
    }

    /**
     * @param t2t2d
     */
    public void setT2t2d(Float t2t2d) {
        this.t2t2d = t2t2d;
    }

    /**
     * @return t3t3d
     */
    public Float getT3t3d() {
        return t3t3d;
    }

    /**
     * @param t3t3d
     */
    public void setT3t3d(Float t3t3d) {
        this.t3t3d = t3t3d;
    }

    /**
     * @return t4t4d
     */
    public Float getT4t4d() {
        return t4t4d;
    }

    /**
     * @param t4t4d
     */
    public void setT4t4d(Float t4t4d) {
        this.t4t4d = t4t4d;
    }

    /**
     * @return i2i2d
     */
    public Float getI2i2d() {
        return i2i2d;
    }

    /**
     * @param i2i2d
     */
    public void setI2i2d(Float i2i2d) {
        this.i2i2d = i2i2d;
    }

    /**
     * @return i32i2
     */
    public Float getI32i2() {
        return i32i2;
    }

    /**
     * @param i32i2
     */
    public void setI32i2(Float i32i2) {
        this.i32i2 = i32i2;
    }

    /**
     * @return i40
     */
    public Float getI40() {
        return i40;
    }

    /**
     * @param i40
     */
    public void setI40(Float i40) {
        this.i40 = i40;
    }

    /**
     * @return i50
     */
    public Float getI50() {
        return i50;
    }

    /**
     * @param i50
     */
    public void setI50(Float i50) {
        this.i50 = i50;
    }

    /**
     * @return t5t5d
     */
    public Float getT5t5d() {
        return t5t5d;
    }

    /**
     * @param t5t5d
     */
    public void setT5t5d(Float t5t5d) {
        this.t5t5d = t5t5d;
    }

    /**
     * @return t1t0t1dt0d
     */
    public Float getT1t0t1dt0d() {
        return t1t0t1dt0d;
    }

    /**
     * @param t1t0t1dt0d
     */
    public void setT1t0t1dt0d(Float t1t0t1dt0d) {
        this.t1t0t1dt0d = t1t0t1dt0d;
    }

    /**
     * @return t2t1t2dt1d
     */
    public Float getT2t1t2dt1d() {
        return t2t1t2dt1d;
    }

    /**
     * @param t2t1t2dt1d
     */
    public void setT2t1t2dt1d(Float t2t1t2dt1d) {
        this.t2t1t2dt1d = t2t1t2dt1d;
    }

    /**
     * 获取动作(合闸、分闸)发生后的电流A相
     *
     * @return lastaacurrent - 动作(合闸、分闸)发生后的电流A相
     */
    public Float getLastaacurrent() {
        return lastaacurrent;
    }

    /**
     * 设置动作(合闸、分闸)发生后的电流A相
     *
     * @param lastaacurrent 动作(合闸、分闸)发生后的电流A相
     */
    public void setLastaacurrent(Float lastaacurrent) {
        this.lastaacurrent = lastaacurrent;
    }

    /**
     * @return lastbacurrent
     */
    public Float getLastbacurrent() {
        return lastbacurrent;
    }

    /**
     * @param lastbacurrent
     */
    public void setLastbacurrent(Float lastbacurrent) {
        this.lastbacurrent = lastbacurrent;
    }

    /**
     * 获取断路器B相电流
     *
     * @return lastcacurrent - 断路器B相电流
     */
    public Float getLastcacurrent() {
        return lastcacurrent;
    }

    /**
     * 设置断路器B相电流
     *
     * @param lastcacurrent 断路器B相电流
     */
    public void setLastcacurrent(Float lastcacurrent) {
        this.lastcacurrent = lastcacurrent;
    }

    /**
     * 获取断路器B相电流
     *
     * @return lastaastatus - 断路器B相电流
     */
    public Integer getLastaastatus() {
        return lastaastatus;
    }

    /**
     * 设置断路器B相电流
     *
     * @param lastaastatus 断路器B相电流
     */
    public void setLastaastatus(Integer lastaastatus) {
        this.lastaastatus = lastaastatus;
    }

    /**
     * 获取断路器B相电流
     *
     * @return lastbastatus - 断路器B相电流
     */
    public Integer getLastbastatus() {
        return lastbastatus;
    }

    /**
     * 设置断路器B相电流
     *
     * @param lastbastatus 断路器B相电流
     */
    public void setLastbastatus(Integer lastbastatus) {
        this.lastbastatus = lastbastatus;
    }

    /**
     * 获取断路器B相电流
     *
     * @return lastcastatus - 断路器B相电流
     */
    public Integer getLastcastatus() {
        return lastcastatus;
    }

    /**
     * 设置断路器B相电流
     *
     * @param lastcastatus 断路器B相电流
     */
    public void setLastcastatus(Integer lastcastatus) {
        this.lastcastatus = lastcastatus;
    }

    /**
     * @return coeconfig
     */
    public Float getCoeconfig() {
        return coeconfig;
    }

    /**
     * @param coeconfig
     */
    public void setCoeconfig(Float coeconfig) {
        this.coeconfig = coeconfig;
    }

    /**
     * @return ratioconfig
     */
    public Float getRatioconfig() {
        return ratioconfig;
    }

    /**
     * @param ratioconfig
     */
    public void setRatioconfig(Float ratioconfig) {
        this.ratioconfig = ratioconfig;
    }

    /**
     * @return maxlifeconfig
     */
    public Float getMaxlifeconfig() {
        return maxlifeconfig;
    }

    /**
     * @param maxlifeconfig
     */
    public void setMaxlifeconfig(Float maxlifeconfig) {
        this.maxlifeconfig = maxlifeconfig;
    }

    /**
     * 获取字段的显示和隐藏
     *
     * @return style - 字段的显示和隐藏
     */
    public String getStyle() {
        return style;
    }

    /**
     * 设置字段的显示和隐藏
     *
     * @param style 字段的显示和隐藏
     */
    public void setStyle(String style) {
        this.style = style;
    }

    /**
     * 获取该指标0或者1判断是否将该条数据上传过61850,如果没有则上传,默认1已上传
     *
     * @return upload - 该指标0或者1判断是否将该条数据上传过61850,如果没有则上传,默认1已上传
     */
    public Integer getUpload() {
        return upload;
    }

    /**
     * 设置该指标0或者1判断是否将该条数据上传过61850,如果没有则上传,默认1已上传
     *
     * @param upload 该指标0或者1判断是否将该条数据上传过61850,如果没有则上传,默认1已上传
     */
    public void setUpload(Integer upload) {
        this.upload = upload;
    }

    /**
     * 获取备注信息。
     *
     * @return memo - 备注信息。
     */
    public String getMemo() {
        return memo;
    }

    /**
     * 设置备注信息。
     *
     * @param memo 备注信息。
     */
    public void setMemo(String memo) {
        this.memo = memo;
    }

    /**
     * @return lastst0time
     */
    public Integer getLastst0time() {
        return lastst0time;
    }

    /**
     * @param lastst0time
     */
    public void setLastst0time(Integer lastst0time) {
        this.lastst0time = lastst0time;
    }

    /**
     * @return lastst1time
     */
    public Integer getLastst1time() {
        return lastst1time;
    }

    /**
     * @param lastst1time
     */
    public void setLastst1time(Integer lastst1time) {
        this.lastst1time = lastst1time;
    }

    /**
     * @return lastst2time
     */
    public Integer getLastst2time() {
        return lastst2time;
    }

    /**
     * @param lastst2time
     */
    public void setLastst2time(Integer lastst2time) {
        this.lastst2time = lastst2time;
    }

    /**
     * @return lastst3time
     */
    public Integer getLastst3time() {
        return lastst3time;
    }

    /**
     * @param lastst3time
     */
    public void setLastst3time(Integer lastst3time) {
        this.lastst3time = lastst3time;
    }

    /**
     * @return lastst4time
     */
    public Integer getLastst4time() {
        return lastst4time;
    }

    /**
     * @param lastst4time
     */
    public void setLastst4time(Integer lastst4time) {
        this.lastst4time = lastst4time;
    }

    /**
     * @return lastst5time
     */
    public Integer getLastst5time() {
        return lastst5time;
    }

    /**
     * @param lastst5time
     */
    public void setLastst5time(Integer lastst5time) {
        this.lastst5time = lastst5time;
    }

    /**
     * 获取s0行程
     *
     * @return lasts0 - s0行程
     */
    public Integer getLasts0() {
        return lasts0;
    }

    /**
     * 设置s0行程
     *
     * @param lasts0 s0行程
     */
    public void setLasts0(Integer lasts0) {
        this.lasts0 = lasts0;
    }

    /**
     * 获取s1行程
     *
     * @return lasts1 - s1行程
     */
    public Integer getLasts1() {
        return lasts1;
    }

    /**
     * 设置s1行程
     *
     * @param lasts1 s1行程
     */
    public void setLasts1(Integer lasts1) {
        this.lasts1 = lasts1;
    }

    /**
     * 获取s2行程
     *
     * @return lasts2 - s2行程
     */
    public Integer getLasts2() {
        return lasts2;
    }

    /**
     * 设置s2行程
     *
     * @param lasts2 s2行程
     */
    public void setLasts2(Integer lasts2) {
        this.lasts2 = lasts2;
    }

    /**
     * @return lasts3
     */
    public Integer getLasts3() {
        return lasts3;
    }

    /**
     * @param lasts3
     */
    public void setLasts3(Integer lasts3) {
        this.lasts3 = lasts3;
    }

    /**
     * @return lasts4
     */
    public Integer getLasts4() {
        return lasts4;
    }

    /**
     * @param lasts4
     */
    public void setLasts4(Integer lasts4) {
        this.lasts4 = lasts4;
    }

    /**
     * @return lasts5
     */
    public Integer getLasts5() {
        return lasts5;
    }

    /**
     * @param lasts5
     */
    public void setLasts5(Integer lasts5) {
        this.lasts5 = lasts5;
    }

    /**
     * 获取刚分合
     *
     * @return lastspeed - 刚分合
     */
    public Float getLastspeed() {
        return lastspeed;
    }

    /**
     * 设置刚分合
     *
     * @param lastspeed 刚分合
     */
    public void setLastspeed(Float lastspeed) {
        this.lastspeed = lastspeed;
    }

    /**
     * @return trip
     */
    public Integer getTrip() {
        return trip;
    }

    /**
     * @param trip
     */
    public void setTrip(Integer trip) {
        this.trip = trip;
    }

    /**
     * @return od
     */
    public Integer getOd() {
        return od;
    }

    /**
     * @param od
     */
    public void setOd(Integer od) {
        this.od = od;
    }

    /**
     * @return firsts2
     */
    public Integer getFirsts2() {
        return firsts2;
    }

    /**
     * @param firsts2
     */
    public void setFirsts2(Integer firsts2) {
        this.firsts2 = firsts2;
    }
}